package day9.homework;

import java.util.Random;

//a.通过线程实现消费者和生产者购买商品的功能:
//定义一个类产品类：属性 产品名称   最大数量   当前数量
//       一个消费者线程类：属性 产品类对象
//       一个生产者线程类:  属性  产品类对象
//       一个测试类：初始化，运行
//要求:生产者线程，当当前数量<最大数量时候.  生产者要进行生产.提示生产数量和当前数量
//        生产结束后,提示消费者可以购买。
//        消费者线程, 消费者购买商品数量随机数而定，不能超过商品最大数量,如果购买数量大于商品当前数量.
//        需要提示 购买的数量，库存不足。   呼叫生产者开始生产物品
//        如果购买的商品数量小于商品当前数量则。正常购买 ，提示购买的数量和剩余数量
public
class Demo3 {
    public static
    void main(String[] args) {
        Product product = new Product( 100, 50);
        new Thread(new Producer(product)).start();
        new Thread(new Consumer(product)).start();
    }
}
class Product{
    String name;
    int maxmuns;
    int muns;
    public Product(int maxmuns,int muns){
        this.maxmuns=maxmuns;
        this.muns=muns;
    }
}
class Producer implements Runnable{
    Product p;
    public
    Producer(Product p) {
        this.p=p;
    }
    @Override
    public
    void run() {
        int i=0;
        while (true) {
            synchronized (p) {
                int x=0;
                while (p.muns<p.maxmuns) {
                    i += 10;
                    if (10 + p.muns>= p.maxmuns) {
                        x = i-10+p.maxmuns - p.muns;
                        p.muns= p.maxmuns;
                        System.out.println("已经生产：" + x + " 当前数量：" + p.muns);
                        System.out.println("生产完毕，消费者可以购买");
                        p.notifyAll();
                        try {
                            i=0;
                            p.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        };
                    } else {
                        p.muns += 10;
                        System.out.println("已经生产：" + i + " 当前数量：" + p.muns);
                        try {
                            Thread.sleep(50);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        }
    }
}
class Consumer implements Runnable{
    Product p;
    public
    Consumer(Product p) {
        this.p=p;
    }
    Random r=new Random();
    int numberOfPurchases;
    @Override
    public
    void run() {
        while (true) {
            synchronized (p) {
                while (p.muns>=0){
                    numberOfPurchases=r.nextInt(p.maxmuns)+1;
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    if (p.muns>=numberOfPurchases && p.muns>0) {
                        p.muns-=numberOfPurchases;
                        System.out.println("购买量："+numberOfPurchases+" 剩余量："+p.muns);
                    }else {
                        System.out.println("需要购买"+numberOfPurchases+" 余量"+p.muns+" 不足，呼叫生产者开始生产物品");
                        try {
                            p.notifyAll();
                            p.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}
